Finding the Most Dangerous Road in Maryland

Andrew McNamara

There are many roads here in Maryland witha reputation for being dangerous. For example, here in College Park, Route One has something of a reputation for being dangerous.
For this project I wanted to evaluate which roads in Maryland are actually the most dangerous and see if I could get some insights about why this may be the case. I found a dataset on Maryland's opendata of all crashes in Maryland since 2015. I downloaded it locally since opendata.maryland.gov goes down for maintenence not infrequently, but attatched is a link to where I got the dataset: https://opendata.maryland.gov/Public-Safety/Maryland-Statewide-Vehicle-Crashes/65du-s3qu.

Collection and Curation¶

In [1]:
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
import statsmodels.api as sm
import statsmodels.formula.api as smf
import sklearn
import folium
from datetime import datetime
crashes = pd.read_csv(r'Maryland_Statewide_Vehicle_Crashes.csv')

    

/opt/conda/lib/python3.9/site-packages/statsmodels/compat/pandas.py:65: FutureWarning: pandas.Int64Index is deprecated and will be removed from pandas in a future version. Use pandas.Index with the appropriate dtype instead.
  from pandas import Int64Index as NumericIndex
/tmp/ipykernel_78/2716668262.py:10: DtypeWarning: Columns (33,45) have mixed types. Specify dtype option on import or set low_memory=False.
  crashes = pd.read_csv(r'Maryland_Statewide_Vehicle_Crashes.csv')

The dataset was large to a point where my computer was struggling, so since I'm looking to evaluate Route One in context of other roads in Maryland, I only looked at data which had named roads, as well as restricting the years being looked at to only 2021 and 2022. I then took out some road names that weren't appropriate, such as 'ENT TO BUSINESS' or 'NO NAME'. This was to ensure I was only looking at roads that were truly roads and not just some catch all referring to multiple locations. I also removed all crashes without latitude and longitude since I'm looking to map the data.

In [2]:
#crashes = crashes[crashes['COUNTY_DESC'] =='Prince George\'s' ]
crashes = crashes[pd.notnull(crashes['REFERENCE_ROAD_NAME'])]
crashes = crashes[pd.notnull(crashes['LATITUDE'])]
crashes = crashes[pd.notnull(crashes['LONGITUDE'])]
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ENT TO BUSINESS']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'NO NAME']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'BEGIN BRIDGE']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'CROSSOVER']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'END BRIDGE']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ROAD END']
crashes = crashes[crashes['REFERENCE_ROAD_NAME'] != 'ENT TO SHOPPING CENTER']

crashes = crashes[~crashes['REFERENCE_ROAD_NAME'].str.contains('EXIT')]
display(crashes)
print(len(crashes['REFERENCE_ROAD_NAME'].unique()))
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG_DESC FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION
5 2020 Q2 NaN 6.02 Baltimore City 24.0 NaN NaN Non Intersection 1.0 ... Miles M N NaN NaN NaN NORTH AVE 39.311025 -76.616429 POINT (-76.616429453205 39.311024794431)
7 2022 Q2 NaN 6.02 Baltimore 3.0 NaN 0.0 Intersection Related 3.0 ... Feet F S 0.0 UU NaN QUIET STREAM CT 39.463704 -76.608660 POINT (-76.608659683333 39.46370405)
11 2022 Q2 Daylight 1.00 Cecil 7.0 NaN 0.0 NaN 88.0 ... Miles M N 273.0 MD NaN TELEGRAPH RD 39.699010 -75.814360 POINT (-75.814360383333 39.6990097)
17 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... Feet F N NaN NaN NaN EASTERN BLVD 39.322488 -76.456602 POINT (-76.456602128426 39.32248773136)
24 2021 Q4 Dark Lights On 3.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... Feet F N 3033.0 CO NaN LINDEN AVE 39.250671 -76.693456 POINT (-76.693456366667 39.25067135)
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848799 2022 Q3 Daylight 1.00 Anne Arundel 2.0 NaN 0.0 Not Applicable 0.0 ... Miles M E 607.0 CO NaN OLD STAGE RD 39.158164 -76.628893 POINT (-76.62889296443 39.158163996637)
848800 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 NaN 88.0 ... Feet F N 1300.0 CO NaN REGESTER AVE 39.378626 -76.608568 POINT (-76.608567616667 39.378625966667)
848801 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 Not Applicable 0.0 ... Feet F W 4095.0 CO NaN EBENEZER RD 39.387539 -76.418305 POINT (-76.418304879322 39.387539278395)
848802 2022 Q3 Daylight 1.00 Anne Arundel 2.0 NaN 0.0 Non Intersection 1.0 ... Feet F N 12.0 SR NaN OCEANIC DR 39.019090 -76.403650 POINT (-76.40365 39.01909)
848803 2022 Q3 Dark Lights On 3.00 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... Feet F E 2189.0 CO NaN PARMELEE RD 39.367800 -76.762110 POINT (-76.76211 39.3678)

732391 rows × 55 columns

78893

Exploration¶

I started out with some basic data exploration. I got the number of crashes for each road documented. I then narrowed down to the 100 most dangerous roads in Maryland as defined by number of crashes. By this metric, Route 1 is the tenth most dangerous road in Maryland from 2015 to 2022. This metric is admittedly flawed, since it doesn't take into account road length or capacity or anything of the sort, but for exploration, seeing where the most crashes take place by sheer number is useful.

In [3]:
roadData = crashes['REFERENCE_ROAD_NAME'].value_counts()
roadData = pd.DataFrame({'road':roadData.index,'crashes':roadData.values})
roadData = roadData.head(100)
display(roadData)
display(roadData[roadData['road']=='BALTIMORE AVE'])
road crashes
0 BALTO BELTWAY 3111
1 ANNAPOLIS RD 2518
2 CAPITAL BELTWAY 2150
3 CONNECTICUT AVE 2130
4 BALTIMORE WASHINGTON PKWY 2116
... ... ...
95 MARTIN LUTHER KING JR BLVD 531
96 DULANEY VALLEY RD 528
97 NORTHWEST EXPRESSWAY 528
98 GOOD LUCK RD 524
99 WHITE MARSH BLVD 517

100 rows × 2 columns

road crashes
9 BALTIMORE AVE 1815

Hypothesis testing on number of crashes¶

To figure out if the number of crashes on any given road is significantly different from the average number of crashes on the 100 most crashed on roads, I did a Z-test, since the sample size is large. I found that Route One does not have significantly more crashes than any of the other top 100 roads. Only the top 6 most dangerous roads have crashes significantly different from the mean.

In [4]:
import scipy.stats
roadData['z-score'] = roadData['crashes'].apply(lambda x:(roadData['crashes'].mean()-x)/roadData['crashes'].std()) 
roadData['p-value'] = roadData['z-score'].apply(lambda x: scipy.stats.norm.sf(abs(x))*2)
roadData['Significant'] = roadData['p-value'].apply(lambda x: x<.05)
display(roadData.head(10))
road crashes z-score p-value Significant
0 BALTO BELTWAY 3111 -4.104533 0.000041 True
1 ANNAPOLIS RD 2518 -2.938238 0.003301 True
2 CAPITAL BELTWAY 2150 -2.214466 0.026797 True
3 CONNECTICUT AVE 2130 -2.175131 0.029620 True
4 BALTIMORE WASHINGTON PKWY 2116 -2.147596 0.031746 True
5 PENNSYLVANIA AVE 2115 -2.145629 0.031903 True
6 GEORGIA AVE 1987 -1.893882 0.058241 False
7 LIBERTY RD 1906 -1.734574 0.082816 False
8 CENTRAL AVE 1823 -1.571332 0.116106 False
9 BALTIMORE AVE 1815 -1.555598 0.119804 False

Now that I have the 100 most dangerous roads in Marlyand by sheer number of crashes, I want to go back to the original dataset to figure out if I can learn about why these roads are so dangerous. To do this, I took my dataset and removed all entries that didn't take place on my list of the top 100 most dangerous roads.

In [5]:
roads = roadData['road'].tolist()
crashes = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
crashes['datetime'] = crashes['ACC_DATE'].astype(str)
crashes['datetime'] = crashes['datetime'].apply(lambda x: datetime.strptime(x,"%Y%m%d"))
display(crashes)
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION datetime
5 2020 Q2 NaN 6.02 Baltimore City 24.0 NaN NaN Non Intersection 1.0 ... M N NaN NaN NaN NORTH AVE 39.311025 -76.616429 POINT (-76.616429453205 39.311024794431) 2020-04-30
17 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... F N NaN NaN NaN EASTERN BLVD 39.322488 -76.456602 POINT (-76.456602128426 39.32248773136) 2021-12-01
28 2021 Q4 Daylight 1.00 Baltimore City 24.0 NaN 999.0 Non Intersection 1.0 ... U N 40.0 US NaN EDMONDSON AVE 39.316242 -76.600602 POINT (-76.600602337322 39.31624205) 2021-11-01
31 2021 Q4 Daylight 1.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 1.0 US NaN BELAIR RD 39.383422 -76.499001 POINT (-76.499001276878 39.383421935655) 2021-10-02
100 2021 Q3 Daylight 1.00 Baltimore City 24.0 NaN 999.0 Intersection 2.0 ... F N 648.0 MD E ANNAPOLIS RD 39.283102 -76.646653 POINT (-76.646652592591 39.283101915293) 2021-08-07
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848755 2022 Q3 NaN 5.02 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F S 5.0 MD NaN BRANCH AVE 38.840298 -76.873562 POINT (-76.873561666667 38.840298333333) 2022-07-09
848756 2022 Q3 Dark No Lights 4.00 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... M S 122.0 MD NaN SECURITY BLVD 39.375950 -76.722297 POINT (-76.722296666667 39.37595) 2022-09-23
848765 2022 Q3 Daylight 1.00 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 144.0 MD NaN FREDERICK RD 39.244980 -76.663258 POINT (-76.66325815 39.244980016667) 2022-07-27
848774 2022 Q3 Daylight 1.00 Carroll 6.0 NaN 0.0 Intersection 2.0 ... F N 26.0 MD NaN LIBERTY RD 39.457587 -77.087513 POINT (-77.087512866667 39.457587416667) 2022-07-21
848782 2022 Q3 Daylight 1.00 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F W 295.0 MD NaN BALTIMORE WASHINGTON PKWY 38.918249 -76.940636 POINT (-76.940636 38.918249) 2022-07-03

102406 rows × 56 columns

I mapped all of the crashes from the top ten most crashed on roads on Maryland in order to see if this could provide us any insight about where the most crashes occur. After limiting the crash data to only those belonging to the top ten roads, I assigned a unique color to each road to allow us to differentiate between them more easily.

In [6]:
map_osm = folium.Map(location=[39.0458, -76.6413], zoom_start=9)
roads = roadData['road'].head(10)
top10roads = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
colors = {'ANNAPOLIS RD':'#E74C3C','LIBERTY RD':'#3498DB','BALTO BELTWAY':'#1ABC9C',
          'BALTIMORE AVE':'#000000','CENTRAL AVE':'#F4D03F','CAPITAL BELTWAY':'#E67E22','CONNECTICUT AVE':'#F0F3F4',
         'GEORGIA AVE':'#909497','BALTIMORE WASHINGTON PKWY':'#186A3B','PENNSYLVANIA AVE':'#FFFFFF'}
for index,crash in top10roads.iterrows():
    folium.Circle(location=[crash["LATITUDE"], crash["LONGITUDE"]],fill=True,opacity=0.8,
                  color=colors[crash['REFERENCE_ROAD_NAME']]).add_to(map_osm)
map_osm
Out[6]:
Make this Notebook Trusted to load map: File -> Trust Notebook

We can see some interesting things. For one, Some roads only have crashes intermittently, such as Liberty Road, which has many spots with only intermittent crashes, but then has some spots with many more crashes clustered together, such as near Frederick and Eldensburg
The same is true with Baltimore Avenue, where we can see clusters near College Park and DC, as well as Laurel.
Where we can see that change is in a road like the Baltimore Beltway, where the crash density is more or less consistent all the way aroung.
The most likely reason for this is because of population density. When roads like Liberty Road are near towns, there are more crashes. A road like the Beltway is always right in the middle of a large population, meaning that crashes are more consistent throughout.

Now that we've done this, we should get back to the fact not all of these roads are the same size. If we get the lengths of these roads, we should be able to divide number of crashes by length to get crashes per mile and essentially standardize the crash counts, allowing us to compare these roads on equal footing. In order to do this, I got the length of roads manually and added each in since I couldn't find a good dataset of road lengths in Maryland that could be easily joined on.

In [7]:
roadData['length'] = 0
roadData.index = roadData['road']
In [8]:
roadData.at['BALTO BELTWAY','length'] = 51.46 
roadData.at['ANNAPOLIS RD','length'] = 30.19 
roadData.at['CAPITAL BELTWAY','length'] = 41.7
roadData.at['CONNECTICUT AVE','length'] = 8.3+2.7
roadData.at['BALTIMORE WASHINGTON PKWY','length'] = 32.52
roadData.at['PENNSYLVANIA AVE','length'] = 35.11
roadData.at['GEORGIA AVE','length'] = 24.23
roadData.at['LIBERTY RD','length'] = 44.10 
roadData.at['CENTRAL AVE','length'] = 24.97
roadData.at['BALTIMORE AVE','length'] = 80.86
roadData.at['CRAIN HWY','length'] = 9.56
roadData.at['REISTERSTOWN RD','length'] = 19.16
roadData.at['PULASKI HWY','length'] = 221.31
roadData.at['FREDERICK RD','length'] = 7.57+17.55
roadData.at['BELAIR RD','length'] = 6.9
roadData.at['JOHN HANSON HWY','length'] = 149.67
roadData.at['BRANCH AVE','length'] =  74.34
roadData.at['POWDER MILL RD','length'] =  10.43
roadData.at['KENILWORTH AVE','length'] =  9.4
roadData.at['YORK RD','length'] =  30.06
In [9]:
def crashpermilecalculator(crashes, miles):
    if miles != 0:
        return crashes / miles
    else: 
        return np.nan
    
#roadData['crashes per mile'] = crashpermilecalculator(roadData['crashes'],roadData['length'])
roadData['crashes per mile'] = roadData.apply(lambda x: crashpermilecalculator(x.crashes, x.length), axis=1)
roadData.sort_values(by='crashes per mile',ascending=False, inplace=True,)
cpm_std = roadData.head(20)['crashes per mile'].std()
cpm_mean = roadData.head(20)['crashes per mile'].mean()
def crashpermileTcalculator(crashes):
    if crashes == crashes:
        return (crashes-cpm_mean)/cpm_std
    else: 
        return np.nan
roadData['crashes per mile t'] = roadData['crashes per mile'].apply(crashpermileTcalculator)
roadData['crashes per mile p'] = roadData['crashes per mile t'].apply(lambda x: scipy.stats.t.sf(abs(x), 19))


display(roadData.head(20))
road crashes z-score p-value Significant length crashes per mile crashes per mile t crashes per mile p
road
BELAIR RD BELAIR RD 1604 -1.140609 0.254033 False 6.90 232.463768 2.307658 0.016220
CONNECTICUT AVE CONNECTICUT AVE 2130 -2.175131 0.029620 True 11.00 193.636364 1.702370 0.052496
CRAIN HWY CRAIN HWY 1811 -1.547731 0.121687 False 9.56 189.435146 1.636876 0.059056
KENILWORTH AVE KENILWORTH AVE 1426 -0.790524 0.429222 False 9.40 151.702128 1.048649 0.153748
POWDER MILL RD POWDER MILL RD 1466 -0.869195 0.384741 False 10.43 140.556088 0.874891 0.196279
REISTERSTOWN RD REISTERSTOWN RD 1719 -1.366788 0.171692 False 19.16 89.718163 0.082369 0.467608
ANNAPOLIS RD ANNAPOLIS RD 2518 -2.938238 0.003301 True 30.19 83.405101 -0.016047 0.493682
GEORGIA AVE GEORGIA AVE 1987 -1.893882 0.058241 False 24.23 82.005778 -0.037861 0.485097
CENTRAL AVE CENTRAL AVE 1823 -1.571332 0.116106 False 24.97 73.007609 -0.178135 0.430251
BALTIMORE WASHINGTON PKWY BALTIMORE WASHINGTON PKWY 2116 -2.147596 0.031746 True 32.52 65.067651 -0.301913 0.382999
FREDERICK RD FREDERICK RD 1634 -1.199612 0.230290 False 25.12 65.047771 -0.302223 0.382883
BALTO BELTWAY BALTO BELTWAY 3111 -4.104533 0.000041 True 51.46 60.454722 -0.373825 0.356337
PENNSYLVANIA AVE PENNSYLVANIA AVE 2115 -2.145629 0.031903 True 35.11 60.239248 -0.377184 0.355109
CAPITAL BELTWAY CAPITAL BELTWAY 2150 -2.214466 0.026797 True 41.70 51.558753 -0.512506 0.307102
YORK RD YORK RD 1397 -0.733488 0.463261 False 30.06 46.473719 -0.591777 0.280488
LIBERTY RD LIBERTY RD 1906 -1.734574 0.082816 False 44.10 43.219955 -0.642501 0.264113
BALTIMORE AVE BALTIMORE AVE 1815 -1.555598 0.119804 False 80.86 22.446203 -0.966347 0.173005
BRANCH AVE BRANCH AVE 1505 -0.945899 0.344200 False 74.34 20.244821 -1.000665 0.164782
JOHN HANSON HWY JOHN HANSON HWY 1573 -1.079639 0.280303 False 149.67 10.509788 -1.152426 0.131720
PULASKI HWY PULASKI HWY 1659 -1.248782 0.211745 False 221.31 7.496272 -1.199404 0.122557

After doing this, we can see that Route One is only the seventeenth most dangerous road in Maryland. To find out which of these are statistically significant, we calculated t scores and p values for crashes per mile on these roads.
From the p values, we can see that the only outlier was Belair road, The rest are within a 95% confidence interval.

We can now map our top 10 most dangerous roads by crashes per mile

In [27]:
map_osm = folium.Map(location=[39.0458, -76.6413], zoom_start=9)
roads = roadData['road'].head(10)
top10roads = crashes[crashes['REFERENCE_ROAD_NAME'].isin(roads)]
colors = {'CONNECTICUT AVE':'#E74C3C','BELAIR RD':'#3498DB','CRAIN HWY':'#1ABC9C',
          'KENILWORTH AVE':'#000000','POWDER MILL RD':'#F4D03F','REISTERSTOWN RD':'#E67E22','ANNAPOLIS RD':'#F0F3F4',
         'GEORGIA AVE':'#909497','CENTRAL AVE':'#186A3B','BALTIMORE WASHINGTON PKWY':'#FFFFFF'}
for index,crash in top10roads.iterrows():
    folium.Circle(location=[crash["LATITUDE"], crash["LONGITUDE"]],fill=True,opacity=0.8,
                  color=colors[crash['REFERENCE_ROAD_NAME']]).add_to(map_osm)
map_osm
Out[27]:
Make this Notebook Trusted to load map: File -> Trust Notebook

This yield further insights. We can see that the most dangerous roads tend to be smaller roads neared to population centers. We can see more crashes where roads move near or through major cities like Washington or Baltimore. As well as when they have exits to more major highways like 95.

It's now worth looking into the conditions on these roads to see if we can figure out why they have so many crashes.

In [40]:
plt.figure(figsize=(15, 40))
plt.subplots_adjust(hspace=0.5)
n = 1

for road in roads:
    ax = plt.subplot(5, 2, n)
    ax.set_title(road)

    n+=1
    roadCrashes = crashes[crashes['REFERENCE_ROAD_NAME']==road]
    light_conditions = roadCrashes['LIGHT_DESC'].value_counts()
    ax = light_conditions.plot.pie()
#print(crashes[crashes['REFERENCE_ROAD_NAME']=='BELAIR RD']['LIGHT_DESC'].value_counts())
In [36]:
display(top10roads)
YEAR QUARTER LIGHT_DESC LIGHT_CODE COUNTY_DESC COUNTY_NO MUNI_DESC MUNI_CODE JUNCTION_DESC JUNCTION_CODE ... FEET_MILES_FLAG DISTANCE_DIR_FLAG REFERENCE_NO REFERENCE_TYPE_CODE REFERENCE_SUFFIX REFERENCE_ROAD_NAME LATITUDE LONGITUDE LOCATION datetime
31 2021 Q4 Daylight 1.0 Baltimore 3.0 NaN 0.0 Intersection 2.0 ... F N 1.0 US NaN BELAIR RD 39.383422 -76.499001 POINT (-76.499001276878 39.383421935655) 2021-10-02
100 2021 Q3 Daylight 1.0 Baltimore City 24.0 NaN 999.0 Intersection 2.0 ... F N 648.0 MD E ANNAPOLIS RD 39.283102 -76.646653 POINT (-76.646652592591 39.283101915293) 2021-08-07
1026 2021 Q1 Daylight 1.0 Prince George's 16.0 NaN 0.0 Intersection 2.0 ... F S 450.0 MD NaN ANNAPOLIS RD 38.941544 -76.902942 POINT (-76.902942308593 38.941544413224) 2021-01-15
1194 2022 Q2 Daylight 1.0 Baltimore 3.0 NaN NaN Not Applicable 0.0 ... U W NaN NaN NaN BELAIR RD 39.363208 -76.518258 POINT (-76.518258183333 39.363207716667) 2022-04-22
1362 2021 Q1 Dark Lights On 3.0 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F S 212.0 MD NaN POWDER MILL RD 39.043303 -76.940396 POINT (-76.940396215191 39.043303419598) 2021-02-09
... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ...
848675 2022 Q3 Daylight 1.0 Caroline 5.0 NaN 0.0 Intersection 2.0 ... F S 86.0 CO NaN CENTRAL AVE 39.115075 -75.781911 POINT (-75.78191126209 39.115075101549) 2022-08-11
848682 2022 Q3 Dark No Lights 4.0 Anne Arundel 2.0 NaN 0.0 Not Applicable 0.0 ... F N 295.0 MD NaN BALTIMORE WASHINGTON PKWY 39.210777 -76.649600 POINT (-76.64959965 39.210777083333) 2022-09-06
848710 2022 Q3 Dark Lights On 3.0 Baltimore 3.0 NaN 0.0 Non Intersection 1.0 ... M S 140.0 MD NaN REISTERSTOWN RD 39.380725 -76.740182 POINT (-76.740181666667 39.380725) 2022-09-19
848743 2022 Q3 Daylight 1.0 Charles 8.0 NaN 88.0 Intersection 2.0 ... F E 301.0 US NaN CRAIN HWY 38.542957 -76.978532 POINT (-76.97853217985 38.542956983736) 2022-08-08
848782 2022 Q3 Daylight 1.0 Prince George's 16.0 NaN 0.0 Non Intersection 1.0 ... F W 295.0 MD NaN BALTIMORE WASHINGTON PKWY 38.918249 -76.940636 POINT (-76.940636 38.918249) 2022-07-03

18600 rows × 56 columns

In [ ]: